The C-64 machine code commands:
-------------------------------

* = add one machine cycle if the indexed pointer exceeds the memory page
** = add 1 cycle if a branch jump must be executed. Add 2 cycles if the
     branch must be executed and exceeded the memory page.
                
MEMORY                                MACHINE
ADDR. MODE     COMMAND          CODE   CYCLES
----------     ---------        ----   -----

  ADC     "Add with carry" : Add an operand+carry to accu
          if the result>255, then carry=1, else carry=0
direct         ADC #operand     $69     2
zeropage       ADC operand      $65     3
zeropage,x     ADC operand,x    $75     4
absolute       ADC operand      $6D     4
absolute,x     ADC operand,x    $7D     4*
absolute,y     ADC operand,y    $79     4*
(indirect,x)   ADC (operand,x)  $61     6
(indirect),y   ADC (operand),y  $71     5*

  AND     "AND with accu" : Logical AND for accu and operand
direct         AND #operand     $29     2
zeropage       AND operand      $25     3
zeropage,x     AND operand,x    $35     4
absolute       AND operand      $2D     4
absolute,x     AND operand,x    $3D     4*
absolute,y     AND operand,y    $39     4*
(indirect,x)   AND (operand,x)  $21     6
(indirect),y   AND (operand),y  $31     5*

  ASL     "Arithmetic shift left" : Move operand bits to the left and
          move the bit 7 to carry
accu           ASL A            $0A     2
zeropage       ASL operand      $06     5
zeropage,x     ASL operand,x    $16     6
absolute       ASL operand      $0E     6
absolute,x     ASL operand,x    $1E     7

  BCC     "Branch, if carry is clear" or: ...result is less
relative       BCC operand      $90     2**

  BCS     "Branch, if carry is set" or: ...result is higher or equal
relative       BCS operand      $B0     2**

  BEQ     "Branch, if equal" or: ...result is zero
relative       BEQ operand      $F0     2**

  BIT     "Bit test" : Tests the set bits with carry and gives a result in
          Z flag. Store bits 6 and 7 of the operand to the status register
          (N and V flags). If (operand AND accu=0), Z flag=1
zeropage       BIT operand      $24     3
absolute       BIT operand      $2C     4

  BMI     "Branch, if minus" : result is negative
relative       BMI operand      $30     2**

  BNE     "Branch, if not equal" or: ...result is not zero
relative       BNE operand      $D0     2**

  BPL     "Branch, if positive" : result is positive or zero (not negative)
relative       BPL operand      $10     2**

  BRK     "Break" : Forced interrupt
internal       BRK              $00     7

  BVC     "Branch, if overflow clear" : Branch if no overflow in a result
relative       BVC operand      $50     2**

  BVS     "Branch, if overflow set" : Branch if overflow occurred in a result
relative       BVS operand      $70     2**

  CLC     "Clear carry" : Clears a carry flag (C=0)
internal       CLC              $18     2

  CLD     "Clear decimal" : Clears a BCD mode flag (Binary Coded Decimals)
internal       CLD              $D8     2

  CLI     "Clear interrupt" : Clears interrupt flag, enable interrupts
internal       CLI              $58     2

  CLV     "Clear overflow" : Clears overflow flag
internal       CLV              $B8     2

  CMP     "Compare with accu" : Compares the operand with accu:
          if accu is equal or higher, C=1
          if accu is less, C=0
direct         CMP #operand     $C9     2
zeropage       CMP operand      $C5     3
zeropage,x     CMP operand,x    $D5     4
absolute       CMP operand      $CD     4
absolute,x     CMP operand,x    $DD     4*
absolute,y     CMP operand,y    $D9     4*
(indirect,x)   CMP (operand,x)  $C1     6
(indirect),y   CMP (operand),y  $D1     5*

  CPX     "Compare with X register" : Compares the operand with X-register:
          if X-register is equal or higher, C=1
          if X-register is less, C=0
direct         CPX #operand     $E0     2
zeropage       CPX operand      $E4     3
absolute       CPX operand      $EC     4

  CPY     "Compare with Y register" : Compares the operand with Y-register:
          if Y-register is equal or higher, C=1
          if Y-register is less, C=0
direct         CPY #operand     $C0     2
zeropage       CPY operand      $C4     3
absolute       CPY operand      $CC     4

  DEC     "Decrement" : Decrease the operand by 1
zeropage       DEC operand      $C6     5
zeropage,x     DEC operand,x    $D6     6
absolute       DEC operand      $CE     6
absolute,x     DEC operand,x    $DE     7

  DEX     "Decrement X register" : Decrease the X-register by 1
internal       DEX              $CA     2

  DEY     "Decrement Y register" : Decrease the Y-register by 1
internal       DEY              $88     2

  EOR     "Exclusive OR with accu" : Logical EOR for accu and operand
direct         EOR #operand     $49     2
zeropage       EOR operand      $45     3
zeropage,x     EOR operand,x    $55     4
absolute       EOR operand      $4D     4
absolute,x     EOR operand,x    $5D     4*
absolute,y     EOR operand,y    $59     4*
(indirect,x)   EOR (operand,x)  $41     6
(indirect),y   EOR (operand),y  $51     5*

  INC     "Increment" : Increase the operand by 1
zeropage       INC operand      $E6     5
zeropage,x     INC operand,x    $F6     6
absolute       INC operand      $EE     6
absolute,x     INC operand,x    $FE     7

  INX     "Increment X register" : Increase the X-register by 1
internal       INX              $E8     2

  INY     "Increment Y register" : Increase the Y-register by 1
internal       INY              $C8     2

  JMP     "Jump" : Jump to the operand specified address
absolute       JMP operand      $4C     3
indirect       JMP (operand)    $6C     5

  JSR     "Jump subroutine" : Jump to the subroutine
absolute       JSR operand      $20     6

  LDA     "Load to accu" : Move an operand to accu
direct         LDA #operand     $A9     2
zeropage       LDA operand      $A5     3
zeropage,x     LDA operand,x    $B5     4
absolute       LDA operand      $AD     4
absolute,x     LDA operand,x    $BD     4*
absolute,y     LDA operand,y    $B9     4*
(indirect,x)   LDA (operand,x)  $A1     6
(indirect),y   LDA (operand),y  $B1     5*

  LDX     "Load to X register" : Move an operand to X-register
direct         LDX #operand     $A2     2
zeropage       LDX operand      $A6     3
zeropage,y     LDX operand,y    $B6     4
absolute       LDX operand      $AE     4
absolute,y     LDX operand,y    $BE     4*

  LDY     "Load to Y register" : Move an operand to Y-register
direct         LDY #operand     $A0     2
zeropage       LDY operand      $A4     3
zeropage,x     LDY operand,x    $B4     4
absolute       LDY operand      $AC     4
absolute,x     LDY operand,x    $BC     4*

  LSR     "Logical shift right" : Move operand bits to the right and
          move the bit 0 to carry
accu           LSR A            $4A     2
zeropage       LSR operand      $46     5
zeropage,x     LSR operand,x    $56     6
absolute       LSR operand      $4E     6
absolute,x     LSR operand,x    $5E     7

  NOP     "No operation"
internal       NOP              $EA     2

  ORA     "OR with accu" : Logical OR for accu and operand
direct         ORA #operand     $09     2
zeropage       ORA operand      $05     3
zeropage,x     ORA operand,x    $15     4
absolute       ORA operand      $0D     4
absolute,x     ORA operand,x    $1D     4*
absolute,y     ORA operand,y    $19     4*
(indirect,x)   ORA (operand,x)  $01     6
(indirect),y   ORA (operand),y  $11     5*

  PHA     "Push accu" : Push accu contents to the stack memory
internal       PHA              $48     3

  PHP     "Push status" : Push processor status-reg. to stack memory (flags)
internal       PHP              $08     3

  PLA     "Pull accu" : Read accu contents from the stack memory
internal       PLA              $68     4

  PLP     "Pull status" : Read status register from the stack memory (flags)
internal       PLP              $28     4

  ROL     "Rotate left" : Roll operand bits to the left.
          Carry moves to operand bit 0.
          Operand bit 7 will be moved to carry.
accu           ROL A            $2A     2
zeropage       ROL operand      $26     5
zeropage,x     ROL operand,x    $36     6
absolute       ROL operand      $2E     6
absolute,x     ROL operand,x    $3E     7

  ROR     "Rotate right" : Roll operand bits to the right.
          Carry moves to operand bit 7.
          Operand bit 0 will be moved to carry.
accu           ROR A            $6A     2
zeropage       ROR operand      $66     5
zeropage,x     ROR operand,x    $76     6
absolute       ROR operand      $6E     6
absolute,x     ROR operand,x    $7E     7

  RTI     "Return from interrupt"
internal       RTI              $40     6

  RTS     "Return from subroutine"
internal       RTS              $60     6

  SBC     "Subtract with carry" : Subtracts an operand from accu.
          if Carry=0, then result will be additionally subtracted by 1.
          if accu<operand, then Carry=0. else Carry=1
direct         SBC #operand     $E9     2
zeropage       SBC operand      $E5     3
zeropage,x     SBC operand,x    $F5     4
absolute       SBC operand      $ED     4
absolute,x     SBC operand,x    $FD     4*
absolute,y     SBC operand,y    $F9     4*
(indirect,x)   SBC (operand,x)  $E1     6
(indirect),y   SBC (operand),y  $F1     5*

  SEC     "Set carry" : Set carry flag (C=1)
internal       SEC              $38     2

  SED     "Set decimal" : Set decimal mode (Binary Coded Decimals)
internal       SED              $F8     2

  SEI     "Set interrupt" : Sets interrupt flag, disable interrupts
          (no effect for NMI interrupts)
internal       SEI              $78     2

  STA     "Store accu" : Copy accu to the address defined by operand
zeropage       STA operand      $85     3
zeropage,x     STA operand,x    $95     4
absolute       STA operand      $8D     4
absolute,x     STA operand,x    $9D     4
absolute,y     STA operand,y    $99     4
(indirect,x)   STA (operand,x)  $81     6
(indirect),y   STA (operand),y  $91     5

  STX     "Store X register" : Copy X-register to the address defined
          by operand
zeropage       STX operand      $86     3
zeropage,y     STX operand,y    $96     4
absolute       STX operand      $8E     4

  STY     "Load to Y register" : Copy Y-register to the address defined
          by operand
zeropage       STY operand      $84     3
zeropage,x     STY operand,x    $94     4
absolute       STY operand      $8C     4

  TAX     "Transfer accu to X register" : copies accu to x-reg
internal       TAX              $AA     2

  TAY     "Transfer accu to Y register" : copies accu to y-reg
internal       TAY              $A8     2

  TSX     "Transfer stack pointer to X register" : copy S-reg. to X-reg.
internal       TSX              $BA     2

  TXA     "Transfer X register to accu" : copies x-reg to accu
internal       TXA              $8A     2

  TXS     "Transfer X register to stack pointer" : copy X-reg. to S-reg.
internal       TXS              $9A     2

  TYA     "Transfer Y register to accu" : copies y-reg to accu
internal       TYA              $98     2



